package org.example.camundaapp.service;

import org.camunda.bpm.engine.task.DelegationState;
import org.camunda.bpm.engine.task.Task;
import org.example.camundaapp.dto.TaskDTO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @className: TaskService
 * @author: ZHRJ
 * @date: 2025-07-04 14:22
 * @Version: 1.0
 * @description:
 */
@Service
public class CamundaTaskService {

    private final CamundaEngineService camundaEngineService;

    @Autowired
    public CamundaTaskService(CamundaEngineService camundaEngineService) {
        this.camundaEngineService = camundaEngineService;
    }

    /**
     * 获取用户待办任务列表 （推荐）
     * @param userId
     * @param processInstanceId
     * @return
     */
    public List<TaskDTO> getPendingTasks(String userId, String processInstanceId) {
        List<Task> tasks = camundaEngineService.getPendingTasks(userId, processInstanceId);
        return tasks.stream()
                .map(TaskDTO::new)
                .collect(Collectors.toList());
    }
        /**
         * 获取用户任务列表
         * @param userId
         * @param taskName
         * @param taskStatus 任务状态：1：已完成；0：待处理
         * @return 如果存在并行审批人的情况下，只返回入参指定人员的任务列表
         */
    public List<TaskDTO> getUserTasks(String userId, String taskName, String taskStatus) {
        //List<Task> tasks = camundaEngineService.getUserTasks(userId);
        DelegationState delegationState = null;
        if(null != taskStatus){
            if("1".equals(taskStatus)){ // 已完成
                delegationState = DelegationState.RESOLVED;
            }else{
                delegationState = DelegationState.PENDING;
            }
        }
        List<Task> tasks = camundaEngineService.getUserTasks(userId, taskName, delegationState);

        return tasks.stream().map(TaskDTO::new).collect(Collectors.toList());
    }

    /**
     * 查询用户任务列表，返回前端需要的格式
     * @param assignee 任务受让人 assignee=${}
     * @return 如果存在并行审批人的情况下，只返回入参指定人员的任务列表
     */
    public List<Map<String, Object>> getUserTasks(String assignee) {
        // 查询用户待办任务
        List<Task> tasks = camundaEngineService.getUserTasksByAssignee(assignee);

        // 转换为前端需要的格式
        List<Map<String, Object>> result = tasks.stream()
                .map(task -> {
                    Map<String, Object> taskInfo = new HashMap<>();
                    taskInfo.put("taskId", task.getId());
                    taskInfo.put("taskName", task.getName());
                    taskInfo.put("processInstanceId", task.getProcessInstanceId());
                    return taskInfo;
                })
                .collect(Collectors.toList());

        return result;
    }

    /**
     * 通过流程实例获取用户任务列表
     * @param instanceId 流程实例
     * @return 如果存在并行审批人的情况下，会返回当前任务下所有需要审批的人员任务列表
     */
    public List<TaskDTO> queryTasksByInstanceId(String instanceId) {
        return camundaEngineService.queryTasksByInstanceId(instanceId).stream().map(TaskDTO::new).collect(Collectors.toList());
    }

    /**
     * 通过指定的流程变量获取用户任务列表
     * @param variableName 流程变量名称
     * @param variableValue 流程受人值
     * @return 如果存在并行审批人的情况下，会返回当前任务下所有需要审批的人员任务列表
     */
    public List<TaskDTO> queryTasksByInitiator(String variableName, String variableValue) {
        return camundaEngineService.queryTasksByInitiator(variableName, variableValue).stream().map(TaskDTO::new).collect(Collectors.toList());}


    /**
     * 审批任务逻辑 （推荐）
     * @param taskId 任务 ID
     * @param approver 审批人
     * @param decision 审批决定
     * @param comment 审批意见
     * @param variables 流程变量
     */
    public void completeApprovalTask(String taskId, String approver, String decision, String comment, Map<String, Object> variables) {
        camundaEngineService.completeApprovalTask(taskId, approver, decision, comment, variables);
    }

    /**
     * 审批任务逻辑
     * @param taskId
     * @param approve
     * @param variables
     */
    public void completeTask(String taskId,Boolean approve,Map<String, Object> variables) {
        // 审批逻辑
        if (approve != null) {
            if (variables == null) variables = new HashMap<>();
            variables.put("approved", approve);
        }
        // 完成任务
        camundaEngineService.completeTask(taskId, variables);
    }
    /**
     * 完成任务
     * @param taskId 任务id
     * @param variables 流程变量
     */
    public void completeTask(String taskId, Map<String, Object> variables) {
        camundaEngineService.completeTask(taskId, variables);
    }

    /**
     * 任务跳转
     * @param currentTaskId 当前任务id
     * @param targetNodeId 目标任务id
     */
    public void jumpTask(String currentTaskId, String targetNodeId) {
        camundaEngineService.jumpTask(currentTaskId, targetNodeId);
    }
    // 获取并行审批任务列表
    public List<TaskDTO> getParallelTasks(String processInstanceId,String assignee) {
        return camundaEngineService.getParallelTasks(processInstanceId,assignee).stream().map(TaskDTO::new).collect(Collectors.toList());
    }

    /**
     * 认领任务
     * @param taskId 任务id
     * @param assignee 任务认领人
     */
    public void claimTask(String taskId, String assignee) {
        // 1、判断任务当前状态是否已被认领
        Task task = camundaEngineService.queryTaskById(taskId);
        if (task.getAssignee() != null) {
            throw new RuntimeException("任务已被认领");
        }

        camundaEngineService.claimTask(taskId, assignee);
    }

    /**
     * 为任务添加新的候选人
     * @param taskId 任务id
     * @param candidateUsers 候选人列表
     */
    public void addCandidateUsers(String taskId, List<String> candidateUsers) {
        for (String candidateUser : candidateUsers) {
            camundaEngineService.addCandidateUser(taskId, candidateUser);
        }
    }

    /**
     * 获取候选任务列表
     * @param userId 用户id
     * @return
     */
    public List<TaskDTO> getCandidateTasks(String userId) {
        List<Task> tasks = camundaEngineService.getCandidateTasks(userId);
        return tasks.stream().map(TaskDTO::new).collect(Collectors.toList());
    }

    /**
     * 获取任务当前状态
     * @param taskId
     * @return 任务当前状态: 待认领、已认领、已解决、已委托、已完成
     */
    public String getTaskCurrentStatus(String taskId) {
        Task task = camundaEngineService.queryTaskById(taskId);

        if (task == null) {
            return "已完成";
        }

        if (task.getAssignee() == null) {
            return "待认领";
        }

        if (task.getDelegationState() != null) {
            if (task.getDelegationState() == DelegationState.PENDING) {
                return "已委托";
            } else if (task.getDelegationState() == DelegationState.RESOLVED) {
                return "已解决";
            }
        }

        return "已认领";
    }
}
